home *** CD-ROM | disk | FTP | other *** search
/ Adobe Graphics & Publishing SDK 1996 December / Adobe Graphics & Publishing SDK 1996 December.iso / pc / ps40sdk / examples / selection / selectorama / common / selectoramascripting.c < prev   
Encoding:
C/C++ Source or Header  |  1996-08-09  |  4.8 KB  |  222 lines
  1. /*
  2.     File: SelectoramaScripting.c
  3.  
  4.     Copyright 1996 by Adobe Systems, Inc.
  5.  
  6.     C source file for scripting functions for Selectorama example.
  7. */
  8.  
  9. #include "Selectorama.h"
  10.  
  11. /*****************************************************************************/
  12.  
  13. /* Checks the parameters against scripting-returned parameters, if any, and
  14.    updates our parameters to match ones given to us by the scripting system. */
  15.  
  16. Boolean ReadScriptParams (GPtr globals)
  17. {
  18.     PIReadDescriptor            token = NULL;
  19.     DescriptorKeyID                key = NULLID;
  20.     DescriptorTypeID            type = NULLID;
  21.     double                        percent = 0;
  22.     const double                minValue = kPercentMin, maxValue = kPercentMax;
  23.     unsigned long                percentUnitPass = unitPercent;
  24.     OSType                        x = typeNull;
  25.     DescriptorKeyIDArray        array = { keyShape, keyChannels, keyCreate, NULLID };
  26.     int32                        flags = 0;
  27.     OSErr                        gotErr = noErr, stickyError = noErr;
  28.     Boolean                        returnValue = true;
  29.     
  30.     if (DescriptorAvailable())
  31.     { /* playing back.  Do our thing. */
  32.         token = OpenReader(array);
  33.         if (token)
  34.         {
  35.             while (PIGetKey(token, &key, &type, &flags))
  36.             {
  37.                 switch (key)
  38.                 {
  39.                     case keyArea:
  40.                         PIGetEnum(token, &x);
  41.                         gWhatArea = KeyToEnum(x, typeSelect);
  42.                         break;
  43.                     case keyAmount: // optional
  44.                         PIGetPinUnitFloat(token, &minValue, &maxValue, &percentUnitPass, &percent);
  45.                         gPercent = (short)percent;
  46.                         break;
  47.                     case keyChannels:
  48.                         PIGetEnum(token, &x);
  49.                         gWhatChannels = KeyToEnum(x, typeComposite);
  50.                         break;
  51.                     case keyCreate:
  52.                         PIGetEnum(token, &x);
  53.                         gCreate = KeyToEnum(x, typeCreate);
  54.                         break;
  55.                 }
  56.             }
  57.  
  58.             stickyError = CloseReader(&token); // closes & disposes.
  59.                 
  60.             if (stickyError)
  61.             {
  62.                 if (stickyError == errMissingParameter) // missedParamErr == -1715
  63.                     ;
  64.                     /* (descriptorKeyIDArray != NULL)
  65.                        missing parameter somewhere.  Walk IDarray to find which one. */
  66.                 else
  67.                     gResult = stickyError;
  68.             }
  69.         }        
  70.         returnValue = PlayDialog();
  71.         /* return TRUE if want to show our Dialog */
  72.     }
  73.     return returnValue;
  74. }
  75.         
  76. /*****************************************************************************/
  77.  
  78. /* Writes our parameters to the scripting system. */
  79.  
  80. OSErr WriteScriptParams (GPtr globals)
  81. {
  82.     PIWriteDescriptor            token = NULL;
  83.     double                        percent = gPercent;
  84.     OSErr                        gotErr = noErr;
  85.             
  86.     if (DescriptorAvailable())
  87.     { /* recording.  Do our thing. */
  88.         token = OpenWriter();
  89.         if (token)
  90.         {
  91.             PIPutEnum(token,
  92.                       keyArea,
  93.                       typeSelect,
  94.                       EnumToKey(gWhatArea, typeSelect));
  95.             if (gWhatArea == iSelectRandom)
  96.                 PIPutUnitFloat(token, keyAmount, unitPercent, &percent);
  97.             PIPutEnum(token,
  98.                       keyChannels,
  99.                       typeComposite,
  100.                       EnumToKey(gWhatChannels, typeComposite));
  101.             PIPutEnum(token,
  102.                       keyCreate,
  103.                       typeCreate,
  104.                       EnumToKey(gCreate, typeCreate));
  105.             gotErr = CloseWriter(&token); /* closes and sets to dialog optional */
  106.         /* done.  Now pass handle on to Photoshop */
  107.         }
  108.     }
  109.     return gotErr;
  110. }
  111.  
  112. /*****************************************************************************/
  113. /* Takes the property units and returns a corresponding enumerated number */
  114.  
  115. short KeyToEnum (OSType key, OSType whatType)
  116. {
  117.     switch (whatType)
  118.     {
  119.         case typeSelect:
  120.             switch (key)
  121.             {
  122.                 case selectMin:
  123.                     return iSelectMin;
  124.                     break;
  125.                 case selectMax:
  126.                     return iSelectMax;
  127.                     break;
  128.                 case selectRandom:
  129.                     return iSelectRandom;
  130.                     break;
  131.             }
  132.             break;
  133.         case typeComposite:
  134.             switch (key)
  135.             {
  136.                 case useTarget:
  137.                     return iUseTarget;
  138.                     break;
  139.                 case useMerged:
  140.                     return iUseMerged;
  141.                     break;
  142.             }
  143.             break;
  144.         case typeCreate:
  145.             switch (key)
  146.             {
  147.                 case createSelection:
  148.                     return iCreateSelection;
  149.                     break;
  150.                 case createMaskpath:
  151.                     return iCreateMaskpath;
  152.                     break;
  153.                 case createLayer:
  154.                     return iCreateLayer;
  155.                     break;
  156.             }
  157.             break;
  158.         case typePISel:
  159.             switch (key)
  160.             {
  161.                 case createSelection:
  162.                     return piSelMakeMask;
  163.                     break;
  164.                 case createMaskpath:
  165.                     return piSelMakeWorkPath;
  166.                     break;
  167.                 case createLayer:
  168.                     return piSelMakeLayer;
  169.                     break;
  170.             }
  171.             break;
  172.     }
  173. }
  174.  
  175. /*****************************************************************************/
  176. /* Takes the property enumeration and returns the corresponding key */
  177.  
  178. OSType EnumToKey (short keyEnum, OSType whatType)
  179.  
  180. {
  181.     switch (whatType)
  182.     {
  183.         case typeSelect:
  184.             switch (keyEnum)
  185.             {
  186.                 case iSelectMin:
  187.                     return selectMin;
  188.                     break;
  189.                 case iSelectMax:
  190.                     return selectMax;
  191.                     break;
  192.                 case iSelectRandom:
  193.                     return selectRandom;
  194.                     break;
  195.             }
  196.         case typeComposite:
  197.             switch (keyEnum)
  198.             {
  199.                 case iUseTarget:
  200.                     return useTarget;
  201.                     break;
  202.                 case iUseMerged:
  203.                     return useMerged;
  204.                     break;
  205.             }
  206.             break;
  207.         case typeCreate:
  208.             switch (keyEnum)
  209.             {
  210.                 case iCreateSelection:
  211.                     return createSelection;
  212.                     break;
  213.                 case iCreateMaskpath:
  214.                     return createMaskpath;
  215.                     break;
  216.                 case iCreateLayer:
  217.                     return createLayer;
  218.                     break;
  219.             }
  220.             break;
  221.     }
  222. }